An explicit mapping between the frequency domain and the time domain representations of nonlinear systems

Explicit expressions are presented that describe the input-output behaviour of a nonlinear system in both the frequency and the time domain. The expressions are based on a set of coefficients that do not depend on the input to the system and are universal for a given system. The anharmonic oscillator is chosen as an example and is discussed for different choices of its physical parameters. It is shown that the typical approach for the determination of the Volterra Series representation is not valid for the important case when the nonlinear system exhibits oscillatory behaviour and the input has a pole at the origin (in the frequency domain), e.g. the unit-step function. For this case, resonant effects arise and the analysis requires additional care.Comment: 27 pages, 5 figures, .pd

Against Oblivion (Part 1)

Music/theatre production for 8 performers (2 vocalists, 2 violins/voices, saxophone, trombone/voice, harpsichord, keyboards) dur. approx 50 min

Safe zero-cost coercions for Haskell

Generative type abstractions – present in Haskell, OCaml, and other languages – are useful concepts to help prevent programmer errors. They serve to create new types that are distinct at compile time but share a run-time representation with some base type. We present a new mechanism that allows for zero-cost conversions between generative type abstractions and their representations, even when such types are deeply nested. We prove type safety in the presence of these conversions and have implemented our work in GHC

Evidence Normalization in System FC (Invited Talk)

System FC is an explicitly typed language that serves as the target language for Haskell source programs. System FC is based on System F with the addition of erasable but explicit type equality proof witnesses. Equality proof witnesses are generated from type inference performed on source Haskell programs. Such witnesses may be very large objects, which causes performance degradation in later stages of compilation, and makes it hard to debug the results of type inference and subsequent program transformations. In this paper we present an equality proof simplification algorithm, implemented in GHC, which greatly reduces the size of the target System FC programs

Submission to the Commons Select Committee on Education

Computing is a rigorous, intellectually rich discipline alongside Maths, Science, or History. Like those subjects, Computing explores foundational principles and ideas, rather than training students in skills that date quickly. In an increasingly digital, knowledge-based age, Computing is fundamental both to full citizenship, and to our economic health as a nation. Yet, incredibly, Computing is virtually absent from UK schools. Instead, secondary schools in England currently teach ICT. The original concept behind ICT was to teach students how to use software to solve real-world problems. That would have been a tremendous achievement had it succeeded. However, what has actually happened in far too many schools is that ICT focuses solely upon IT literacy, and supporting teaching and learning in other curriculum contexts. ICT is not the discipline of understanding and knowledge of computers and the way they work.The creation of the EBac provides the perfect opportunity to send a clear signal to schools and pupils of the importance of Computing. Our key recommendation is that Computing (unlike ICT) should “count” towards the English Baccalaureate.On behalf of Computing at School:Dr. John WoollardProf. Simon Peyton-JonesDr. Bill Mitchel

Linear Haskell: practical linearity in a higher-order polymorphic language

Linear type systems have a long and storied history, but not a clear path forward to integrate with existing languages such as OCaml or Haskell. In this paper, we study a linear type system designed with two crucial properties in mind: backwards-compatibility and code reuse across linear and non-linear users of a library. Only then can the benefits of linear types permeate conventional functional programming. Rather than bifurcate types into linear and non-linear counterparts, we instead attach linearity to function arrows. Linear functions can receive inputs from linearly-bound values, but can also operate over unrestricted, regular values. To demonstrate the efficacy of our linear type system - both how easy it can be integrated in an existing language implementation and how streamlined it makes it to write programs with linear types - we implemented our type system in GHC, the leading Haskell compiler, and demonstrate two kinds of applications of linear types: mutable data with pure interfaces; and enforcing protocols in I/O-performing functions

Levity Polymorphism

Parametric polymorphism is one of the linchpins of modern typed programming, but it comes with a real performance penalty. We describe this penalty; offer a principled way to reason about it (kinds as calling conventions); and propose levity polymorphism. This new form of polymorphism allows abstractions over calling conventions; we detail and verify restrictions that are necessary in order to compile levity-polymorphic functions. Levity polymorphism has created new opportunities in Haskell, including the ability to generalize nearly half of the type classes in GHC\u27s standard library